home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / stacks.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  13.6 KB  |  225 lines
  1. DEFINITION MODULE  Stacks;
  2.  
  3. (*****************************************************************************)
  4. (* Dieses Modul enthaelt Prozeduren zur Erzeugung und Verwaltung eines       *)
  5. (* Stacks (LIFO - List ). Die Stackoperationen sind nicht an einen bestimm-  *)
  6. (* ten Datentyp gebunden, d.h. aber auch, dass keine Typueberpruefung - we-  *)
  7. (* der zur Uebersetzungszeit noch zur Laufzeit - vorgenommen wird.           *)
  8. (*                                                                           *)
  9. (* Um jedoch eine kleine Ueberpruefung zu ermoeglichen, muss bei Einrichtung *)
  10. (* eines Stacks der Speicherplatz der Elemente angegeben werden, fuer die der*)
  11. (* Stack genutzt werden soll; Wird zur Laufzeit beim Hinzufuegen oder Ent-   *)
  12. (* fernen ein Element mit einer anderen Speicherplatzgroesse benutzt, wird   *)
  13. (* dies als Fehler erkannt ( --> sizeErr ).                                  *)
  14. (*                                                                           *)
  15. (* Als weitere Notbremse pruefen alle Prozeduren, ob der Stack, der ihnen    *)
  16. (* uebergeben wird, einen undefinierten Wert hat. Auch hier wird ein Fehler  *)
  17. (* erkannt ( --> defErr ).                                                   *)
  18. (*                                                                           *)
  19. (* Wird ein beliebiger Fehler erkannt, wird dies ueber den Parameter <done>  *)
  20. (* mitgeteilt; eine detailliertere Fehlermeldung erhaelt man ueber die Proze-*)
  21. (* dur "LastStackResult". Auf Wunsch kann auch mit "AssignStackHandler" eine *)
  22. (* automatische Fehlerbehandlung durch das Modul erfolgen.                   *)
  23. (*                                                                           *)
  24. (* Wegen der Pruefung auf undefinierten Stack muessen saemtliche Parameter   *)
  25. (* vom Typ Stack als VAR-Parameter uebergeben werden, obwohl sie manchmal    *)
  26. (* nur Eingangsparameter sind ( siehe Kommentar ).                           *)
  27. (*                                                                           *)
  28. (* Die vorliegende MODULA-2 - Implementation erlaubt nur das Ablegen von     *)
  29. (* einzelnen Variablen auf dem Stack; nicht erlaubt sind Ausdruecke - auch   *)
  30. (* keine Konstanten. Ausdruecke muessen also erst berechnet und einer Varia- *)
  31. (* blen zugewiesen werden, bevor ihr Wert auf dem Stack gespeichert werden   *)
  32. (* kann.                                                                     *)
  33. (*___________________________________________________________________________*)
  34. (*   23-Feb-90 , Holger Kleinschmidt                                         *)
  35. (*****************************************************************************)
  36.  
  37. FROM  SYSTEM  IMPORT  BYTE;
  38.  
  39. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  40.  
  41.    TYPE
  42.          Stack;     (* mehr braucht man nicht zu wissen -> OPAK (ADT)  *)
  43.  
  44.          StackResult  = ( stackOk, defErr, sizeErr, noMem, stackEmpty );
  45.  
  46.          StackHandler = PROCEDURE ((* EIN  proc  *) ARRAY OF CHAR,
  47.                                    (* EIN  stErr *) StackResult   );
  48.  
  49. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  50.  
  51.   PROCEDURE  AssignStackHandler ((* EIN/  -- *) handler : StackHandler );
  52.  
  53.   PROCEDURE  UnAssignStackHandler;
  54.  
  55.  (*-------------------------------------------------------------------------
  56.   | Ist mit "AssignStackHandler" eine Fehlerbehandlungsroutine definiert    |
  57.   | worden, so wird diese jedesmal automatisch aufgerufen, wenn bei einer   |
  58.   | Stackoperation ein Fehler aufgetreten ist; die Prozedur erhaelt als     |
  59.   | Parameter den Fehler vom Typ "StackResult" und den Namen der Prozedur,  |
  60.   | in der der Fehler auftrat.                                              |
  61.   | Nach Programmstart oder Aufruf von "UnAssignStackHandler" wird vom Modul|
  62.   | kein Handler beim Auftritt eines Fehlers aktiviert.                     |
  63.   |                                                                         |
  64.   | Die automatische Fehlermeldung ist besonders in der Testphase zu emp-   |
  65.   | fehlen, eine einfache Routine koennte z.B. so aussehen:                 |
  66.   |                                                                         |
  67.   | PROCEDURE Stackhandler( proc : ARRAY OF CHAR; fehler : StackResult );   |
  68.   |   BEGIN                                                                 |
  69.   |     WriteLn;                                                            |
  70.   |     WriteString('Fehler bei Stackoperation - ');                        |
  71.   |     WriteString('Prozedur '); WriteString(proc); Write(':');            |
  72.   |     WriteLn;                                                            |
  73.   |     CASE  fehler  OF                                                    |
  74.   |      | stackOk   : WriteString('Alles ok');                             |
  75.   |      | defErr    : WriteString('Der benutzte Stack ist undefiniert!');  |
  76.   |      | sizeErr   :                                                      |
  77.   |          WriteString('Das Datenelement hat einen anderen Speicher');    |
  78.   |          WriteString('bedarf,'); WriteLn;                               |
  79.   |          WriteString('als bei der Stackdefinition angegeben.');         |
  80.   |      | noMem     : WriteString('Kein freier Speicher mehr.');           |
  81.   |      | stackEmpty: WriteString('Der Stack ist leer.');                  |
  82.   |      ELSE                                                               |
  83.   |        WriteString('Totaler Zusammenbruch...');                         |
  84.   |     END; (* CASE *)                                                     |
  85.   |     WriteLn; WriteLn;                                                   |
  86.   |   END  Stackhandler;                                                    |
  87.    -------------------------------------------------------------------------*)
  88.  
  89.  
  90.   PROCEDURE  LastStackResult ( ): StackResult;
  91.  
  92.  (*-------------------------------------------------------------------------
  93.   | Liefert das Resultat der letzten Stackoperation, falls <done> nicht aus-|
  94.   | reichen sollte oder fuer die Prozeduren "Length" und "IsEmpty", die     |
  95.   | keinen Erfolgsparameter <done> haben.                                   |
  96.   |                                                                         |
  97.   | Moegliche Kombinationen sind:                                           |
  98.   |  - stackOk    : Es ist kein Fehler aufgetreten. Moegliches Ergebnis     |
  99.   |                 aller Prozeduren.                                       |
  100.   |  - stackEmpty : Es wurde versucht, ein Element von einem leeren Stack   |
  101.   |                 zu holen. Moegliches Ergebnis von "Pop", "TopOfStack"   |
  102.   |                 und "Drop".                                             |
  103.   |  - noMem      : der Speicher reicht nicht fuer die Ausfuehrung von      |
  104.   |                 "Create" oder "Push".                                   |
  105.   |  - sizeErr    : Es wurde versucht, ein Element auf dem Stack abzulegen  |
  106.   |                 oder vom Stack zu holen, das eine andere Speicherplatz- |
  107.   |                 groesse hat, als bei der Definition des Stacks angegeben|
  108.   |                 wurde. Moegliches Ergebnis von "Pop","TopOfStack","Push"|
  109.   |  - defErr     : Es wurde versucht, eine Stackoperation mit einer unde-  |
  110.   |                 finierten Stackvariable auszufuehren. Moegliches Resul- |
  111.   |                 tat aller Prozeduren ausser "Create".                   |
  112.    -------------------------------------------------------------------------*)
  113.  
  114. (*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*)
  115.  
  116.   PROCEDURE  Create ((* EIN/ -- *)     groesse : CARDINAL;
  117.                      (* EIN/ -- *)     blkElem : CARDINAL;
  118.                      (* -- /AUS *) VAR stack   : Stack;
  119.                      (* -- /AUS *) VAR done    : BOOLEAN  );
  120.  
  121.  (*-------------------------------------------------------------------------
  122.   | Richtet einen <stack> und seine Verwaltung ein. <groesse> ist die       |
  123.   | Groesse der Elemente, die auf dem Stack abgelegt werden sollen.         |
  124.   | <blkElem> ist die Anzahl der Elemente, fuer die jeweils, wenn noetig,   |
  125.   | ein neuer Speicherblock angefordert wird; ein grosser Wert fuer         |
  126.   | <blkElem> fuert zu geringerem Verwaltungsaufwand, vergroessert aber den |
  127.   | Anteil des Speichers, der die meiste Zeit nicht genutzt wird.           |
  128.   | Die Prozedur muss vor allen anderen Stackoperationen ausgefuehrt werden;|
  129.   | <stack> ist nur fuer Elemente der angegebenen Groesse zu benutzen.      |
  130.   | <grosse> = 0, <blkElem> = 0 werden auf 1 korrigiert.                    |
  131.   | <stack> ist immer mindestens einen Block gross.                         |
  132.   |                                                                         |
  133.   | Moegliche Fehler: noMem                                                 |
  134.    -------------------------------------------------------------------------*)
  135.  
  136.  
  137.   PROCEDURE  Delete ((* EIN/AUS *) VAR stack : Stack;
  138.                      (* -- /AUS *) VAR done  : BOOLEAN );
  139.  
  140.  (*-------------------------------------------------------------------------
  141.   | Gegenstueck zu "Create": <stack> wird aus der Verwaltung entfernt, und  |
  142.   | der belegte Speicherplatz freigegeben.                                  |
  143.   | <stack> hat nach Ausfuehrung den Wert NIL.                              |
  144.   |                                                                         |
  145.   | Moegliche Fehler: defErr                                                |
  146.    -------------------------------------------------------------------------*)
  147.  
  148.  
  149.   PROCEDURE  Clear ((* EIN/AUS *) VAR stack : Stack;
  150.                     (* -- /AUS *) VAR done  : BOOLEAN );
  151.  
  152.  (*-------------------------------------------------------------------------
  153.   | Entfernt saemtliche Elemente von <stack>, und gibt deren Speicherplatz  |
  154.   | frei; <stack> selber bleibt erhalten.                                   |
  155.   |                                                                         |
  156.   | Moegliche Fehler: defErr                                                |
  157.    -------------------------------------------------------------------------*)
  158.  
  159.  
  160.   PROCEDURE  IsEmpty ((* EIN/ -- *) VAR stack : Stack ): BOOLEAN;
  161.  
  162.  (*-------------------------------------------------------------------------
  163.   | Testet, ob <stack> leer ist.                                            |
  164.   |                                                                         |
  165.   | Moegliche Fehler: defErr                                                |
  166.    -------------------------------------------------------------------------*)
  167.  
  168.   PROCEDURE  Length ((* EIN/ -- *) VAR stack : Stack ): CARDINAL;
  169.  
  170.  (*-------------------------------------------------------------------------
  171.   | Liefert die Anzahl der Elemente von <stack>.                            |
  172.   |                                                                         |
  173.   | Moegliche Fehler: defErr                                                |
  174.    -------------------------------------------------------------------------*)
  175.  
  176.  
  177.   PROCEDURE  Push ((* EIN/ -- *)     wert  : ARRAY OF BYTE;
  178.                    (* EIN/AUS *) VAR stack : Stack;
  179.                    (* -- /AUS *) VAR done  : BOOLEAN       );
  180.  
  181.  (*-------------------------------------------------------------------------
  182.   | Hiermit koennen Elemente auf dem Stack abgelegt werden. Der Datentyp,   |
  183.   | fuer den der Stack genutzt werden kann, wird beim Aufruf von "Create"   |
  184.   | festgelegt, d.h. alle weiteren Elemente, die auf den Stack 'gepushed'   |
  185.   | werden, muessen auch von einem Typ sein, der den gleichen Speicherplatz |
  186.   | belegt ( maschinenabhaengig ).                                          |
  187.   |                                                                         |
  188.   | Moegliche Fehler: defErr, sizeErr, noMem                                |
  189.    -------------------------------------------------------------------------*)
  190.  
  191.  
  192.   PROCEDURE  TopOfStack ((* EIN/ -- *) VAR stack : Stack;
  193.                          (* -- /AUS *) VAR wert  : ARRAY OF BYTE;
  194.                          (* -- /AUS *) VAR done  : BOOLEAN       );
  195.  
  196.  (*-------------------------------------------------------------------------
  197.   | Liefert das oberste Element auf dem Stack; der Stack wird nicht veraen- |
  198.   | dert. War der Stack leer, wird <wert> auf Null gesetzt.                 |
  199.   |                                                                         |
  200.   | Moegliche Fehler: defErr, sizeErr, stackEmpty                           |
  201.    -------------------------------------------------------------------------*)
  202.  
  203.  
  204.   PROCEDURE  Drop ((* EIN/AUS *) VAR stack : Stack;
  205.                    (* -- /AUS *) VAR done  : BOOLEAN );
  206.  
  207.  (*-------------------------------------------------------------------------
  208.   | Entfernt - ohne es zu liefern - das oberste Element von <stack>.        |
  209.   |                                                                         |
  210.   | Moegliche Fehler: defErr, stackEmpty                                    |
  211.    -------------------------------------------------------------------------*)
  212.  
  213.  
  214.   PROCEDURE  Pop ((* EIN/AUS *) VAR stack : Stack;
  215.                   (* -- /AUS *) VAR wert  : ARRAY OF BYTE;
  216.                   (* -- /AUS *) VAR done  : BOOLEAN       );
  217.  
  218.  (*-------------------------------------------------------------------------
  219.   | Vereinigt "TopOfStack" und "Drop"                                       |
  220.   |                                                                         |
  221.   | Moegliche Fehler: defErr, sizeErr, stackEmpty                           |
  222.    -------------------------------------------------------------------------*)
  223.  
  224. END  Stacks.
  225.